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/14] 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/14] 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/14] 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/14] 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 5646af6e2674998696ff3ca6d9134a2a0190e892 Mon Sep 17 00:00:00 2001 From: "John C. Burnham" Date: Fri, 28 Aug 2026 11:48:09 -0400 Subject: [PATCH 05/14] 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 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 06/14] 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 07/14] 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 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 08/14] 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 6c20e1ce984e0522541fe8c6bbefad765d298581 Mon Sep 17 00:00:00 2001 From: "John C. Burnham" Date: Fri, 28 Aug 2026 15:42:03 -0400 Subject: [PATCH 09/14] 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 10/14] 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 11/14] 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 12/14] 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 13/14] 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 14/14] 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